package demo;

public class Test {
    public static void func(Animal animal){
        animal.eat();
    }

    /*public static Animal func2(){
        Dog dog = new Dog("旺财",1);
        return dog;
    }*/

public static int Add(int a,int b){
    return a+b;
}
public static int Add(int a,int b,int c){
    return a+b+c;
}

    public static void main(String[] args) {
        Animal animal = new Bird("小鸟",2);
        Bird bird = (Bird) animal;
        bird.fly();
        System.out.println("=====================================");

        Animal animal2 = new Dog("旺财",1);

        if(animal2 instanceof Bird){
                   Bird bird1 = (Bird) animal2;
                   bird1.fly();
        }else{
            System.out.println("animal2 instanceof Bird not!!!!");
        }
    }
    public static void main3(String[] args) {
        Add(1,2);
        /*静态绑定:
        在编译时,根据用户所传递实参类型就确定具体调用哪个方法
        如:Add方法*/
        Add(1,3,5);
    }
    public static void main2(String[] args) {
        /*多态的实现条件:
        1.必须在继承体系下
        2.子类必须要对父类中方法进行重写
        3.通过父类的引用调用重写方法*/
        Dog dog = new Dog("旺财",1);
        func(dog);
        System.out.println("============");
        Bird bird = new Bird("小鸟",2);
        func(bird);
        /*animal引用的对象 不一样,但是 调用的是同一个方法,
        此时表现出来的现象不一样,此时这种思想,我们就叫做 多态!!!!*/
    }
    public static void main1(String[] args) {
       /* Dog dog = new Dog("旺财",1);
        Animal animal = dog;*/

        //父类引用 引用了子类对象 叫做向上转型

        /*向上转型有三种
         1.直接赋值
         2.方法的传参
         3.返回值*/

        //1.直接赋值     这个就是向上转型
        Animal animal = new Dog("旺财",1);

        animal.eat();
        //为什么通过父类的引用 调用输出的是子类的方法 ????
        /*我们观察 父类和子类的两个方法
        1.方法名相同
        2.参数列表相同(顺序、类型、个数)
        3.返回值相同
        此时这两个方法构成了方法的重写*/

        //2. 方法的传参
        Dog dog = new Dog("旺财",1);
        func(dog);

        //3. 返回值
        /*public static Animal func2(){
            Dog dog = new Dog("旺财",1);
            return dog;
        }*/

    }
}
